export const LanguageData = [
    {
        key: 1,
        name: "castArray",
        remark: "强制转换数组",
        use: "_.castArray(value)",
        description: `
            如果 value 不是数组, 那么强制转为数组。
        `,
        argument: `
value (*): 要处理的值。
        `,
        return: "(Array): 返回转换后的数组。",
        case: `
_.castArray(1);
// => [1]

_.castArray({ 'a': 1 });
// => [{ 'a': 1 }]

_.castArray('abc');
// => ['abc']

_.castArray(null);
// => [null]

_.castArray(undefined);
// => [undefined]

_.castArray();
// => []

var array = [1, 2, 3];
console.log(_.castArray(array) === array);
// => true
        `,
    },
    {
        key: 2,
        name: "clone",
        remark: "浅拷贝数组。",
        use: "_.clone(value)",
        description: `
            创建一个 value 的浅拷贝。
            注意: 这个方法参考自structured clone algorithm 以及支持 arrays、array buffers、 booleans、 date objects、maps、 numbers， Object 对象, regexes, sets, strings, symbols, 以及 typed arrays。 arguments对象的可枚举属性会拷贝为普通对象。 一些不可拷贝的对象，例如error objects、functions, DOM nodes, 以及 WeakMaps 会返回空对象。
        `,
        argument: `
value (*): 要拷贝的值
        `,
        return: "(*): 返回拷贝后的值。",
        case: `
var objects = [{ 'a': 1 }, { 'b': 2 }];

var shallow = _.clone(objects);
console.log(shallow[0] === objects[0]);
// => true
        `,
    },
    {
        key: 3,
        name: "cloneDeep",
        remark: "深拷贝数组",
        use: "_.cloneDeep(value)",
        description: `
这个方法类似_.clone，除了它会递归拷贝 value。（注：也叫深拷贝）。
        `,
        argument: `
value (*): 要深拷贝的值。
        `,
        return: "(*): 返回拷贝后的值。",
        case: `
var objects = [{ 'a': 1 }, { 'b': 2 }];

var deep = _.cloneDeep(objects);
console.log(deep[0] === objects[0]);
// => false
        `,
    },
    {
        key: 4,
        name: "cloneDeepWith",
        remark: "深拷贝【没理解】",
        use: "_.cloneDeepWith(value, [customizer])",
        description: `
这个方法类似_.cloneWith，除了它会递归克隆 value。
        `,
        argument: `
1.value (*): 用来递归克隆的值。
2.[customizer] (Function): 用来自定义克隆的函数。
        `,
        return: "(*): 返回深度克隆后的值。",
        case: `
function customizer(value) {
  if (_.isElement(value)) {
    return value.cloneNode(true);
  }
}

var el = _.cloneDeepWith(document.body, customizer);

console.log(el === document.body);
// => false
console.log(el.nodeName);
// => 'BODY'
console.log(el.childNodes.length);
// => 20
        `,
    },
    {
        key: 5,
        name: "cloneWith",
        remark: "深拷贝【没理解】",
        use: "_.cloneWith(value, [customizer])",
        description: `
这个方法类似_.clone，除了它接受一个 customizer 定制返回的克隆值。 如果 customizer 返回 undefined 将会使用拷贝方法代替处理。 customizer 调用4个参数： (value [, index|key, object, stack])。
        `,
        argument: `
1.value (*): 要克隆的值。
2.[customizer] (Function): 用来自定义克隆的函数。
        `,
        return: "(*): 返回克隆值。",
        case: `
function customizer(value) {
  if (_.isElement(value)) {
    return value.cloneNode(false);
  }
}

var el = _.cloneWith(document.body, customizer);

console.log(el === document.body);
// => false
console.log(el.nodeName);
// => 'BODY'
console.log(el.childNodes.length);
// => 0
        `,
    },
    {
        key: 6,
        name: "conformsTo",
        remark: "检查对象的属性是否符合预期",
        use: "_.conformsTo(object, source)",
        description: `
通过调用断言source的属性与 object 的相应属性值，检查 object是否符合 source。当source偏应用时，这种方法和_.conforms函数是等价的。
注意: 当source为偏应用时，这种方法等价于_.conforms。（注：关于偏应用大家可以自己到google上搜索一下）。
       `,
        argument: `
1.object (Object): 要检查的对象。
2.source (Object): 要断言属性是否符合的对象。
        `,
        return: "(boolean): 如果 object 符合，返回 true，否则 false。",
        case: `
var object = { 'a': 1, 'b': 2 };

_.conformsTo(object, { 'b': function(n) { return n > 1; } });
// => true

_.conformsTo(object, { 'b': function(n) { return n > 2; } });
// => false
        `,
    },
    {
        key: 7,
        name: "eq",
        remark: "比较两者是否相等",
        use: "_.eq(value, other)",
        description: `
执行SameValueZero 比较两者的值，来确定它们是否相等。
       `,
        argument: `
1.value (*): 要比较的值。
2.other (*): 另一个要比较的值。
        `,
        return: "(boolean): 如果两个值相等返回 true ，否则返回 false 。",
        case: `
var object = { 'a': 1 };
var other = { 'a': 1 };

_.eq(object, object);
// => true

_.eq(object, other);
// => false

_.eq('a', 'a');
// => true

_.eq('a', Object('a'));
// => false

_.eq(NaN, NaN);
// => true
        `,
    },
    {
        key: 8,
        name: "gt",
        remark: "比较是否大于，返回Boolean值",
        use: "_.gt(value, other)",
        description: `
            检查 value是否大于 other。
       `,
        argument: `
1.value (*): 要比较的值。
2.other (*): 另一个要比较的值。
        `,
        return: "(boolean): 如果value 大于 other 返回 true，否则返回 false。",
        case: `
_.gt(3, 1);
// => true

_.gt(3, 3);
// => false

_.gt(1, 3);
// => false
        `,
    },
    {
        key: 9,
        name: "gte",
        remark: "比较是否大于或者等于，返回Boolean值",
        use: "_.gte(value, other)",
        description: `
检查 value是否大于或者等于 other。
       `,
        argument: `
1.value (*): 要比较的值。
2.other (*): 另一个要比较的值。
        `,
        return: "(boolean): 如果value 大于或者等于 other 返回 true，否则返回 false。",
        case: `
_.gte(3, 1);
// => true

_.gte(3, 3);
// => true

_.gte(1, 3);
// => false
        `,
    },
    {
        key: 10,
        name: "isArguments",
        remark: "判断是否是类 arguments 对象",
        use: "_.isArguments(value)",
        description: `
            检查 value 是否是一个类 arguments 对象。【arguments对象是所有（非箭头）函数中都可用的局部变量。https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/arguments】
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果value是一个 arguments 对象 返回 true，否则返回 false。",
        case: `
_.isArguments(function() { return arguments; }());
// => true

_.isArguments([1, 2, 3]);
// => false
        `,
    },
    {
        key: 11,
        name: "isArray",
        remark: "判断是否是数组",
        use: "_.isArray(value)",
        description: `
            检查 value 是否是 Array 类对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果value是一个数组返回 true，否则返回 false。",
        case: `
_.isArray([1, 2, 3]);
// => true

_.isArray(document.body.children);
// => false

_.isArray('abc');
// => false

_.isArray(_.noop);
// => false
        `,
    },
    {
        key: 12,
        name: "isArrayBuffer",
        remark: "判断是否是 ArrayBuffer 对象",
        use: "_.isArrayBuffer(value)",
        description: `
            检查 value 是否是 ArrayBuffer 对象。ArrayBuffer 对象用来表示通用的原始二进制数据缓冲区。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果value是一个数组 buffer 返回 true，否则返回 false",
        case: `
_.isArrayBuffer(new ArrayBuffer(2));
// => true

_.isArrayBuffer(new Array(2));
// => false
        `,
    },
    {
        key: 13,
        name: "isArrayLike",
        remark: "判断是否是类数组",
        use: "_.isArrayLike(value)",
        description: `
            检查 value 是否是类数组。 如果一个值被认为是类数组，那么它不是一个函数，并且value.length是个整数，大于等于 0，小于或等于 Number.MAX_SAFE_INTEGER。【类数组与数组区别参照https://juejin.cn/post/7017997007352496136】
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果value是一个类数组，那么返回 true，否则返回 false。",
        case: `
_.isArrayLike([1, 2, 3]);
// => true

_.isArrayLike(document.body.children);
// => true

_.isArrayLike('abc');
// => true

_.isArrayLike(_.noop);
// => false
        `,
    },
    {
        key: 14,
        name: "isArrayLikeObject",
        remark: "判断是否是类数组对象",
        use: "_.isArrayLikeObject(value)",
        description: `
            这个方法类似_.isArrayLike。除了它还检查value是否是个对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个类数组对象，那么返回 true，否则返回 false",
        case: `
_.isArrayLikeObject([1, 2, 3]);
// => true

_.isArrayLikeObject(document.body.children);
// => true

_.isArrayLikeObject('abc');
// => false

_.isArrayLikeObject(_.noop);
// => false
        `,
    },
    {
        key: 15,
        name: "isBoolean",
        remark: "判断是否是boolean类型",
        use: "_.isBoolean(value)",
        description: `
            检查 value 是否是原始 boolean 类型或者对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个布尔值，那么返回 true，否则返回 false。",
        case: `
_.isBoolean(false);
// => true

_.isBoolean(null);
// => false
        `,
    },
    {
        key: 16,
        name: "isBuffer",
        remark: "判断是否是buffer",
        use: "_.isBuffer(value)",
        description: `
            检查 value 是否是个 buffer。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个buffer，那么返回 true，否则返回 false。",
        case: `
_.isBuffer(new Buffer(2));
// => true

_.isBuffer(new Uint8Array(2));
// => false
        `,
    },
    {
        key: 17,
        name: "isDate",
        remark: "判断是否是 Date 对象",
        use: "_.isDate(value)",
        description: `
            检查 value 是否是 Date 对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个日期对象，那么返回 true，否则返回 false。",
        case: `
_.isDate(new Date);
// => true

_.isDate('Mon April 23 2012');
// => false
        `,
    },
    {
        key: 18,
        name: "isElement",
        remark: "判断是否是dom元素",
        use: "_.isElement(value)",
        description: `
            检查 value 是否是可能是 DOM 元素。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个DOM元素，那么返回 true，否则返回 false。",
        case: `
_.isElement(document.body);
// => true

_.isElement('<body>');
// => false
        `,
    },
    {
        key: 19,
        name: "isEmpty",
        remark: "判断是否是空对象",
        use: "_.isEmpty(value)",
        description: `
            检查 value 是否为一个空对象，集合，映射或者set。 判断的依据是除非是有枚举属性的对象，length 大于 0 的 arguments object, array, string 或类jquery选择器。
对象如果被认为为空，那么他们没有自己的可枚举属性的对象。
类数组值，比如arguments对象，array，buffer，string或者类jQuery集合的length 为 0，被认为是空。类似的，map（映射）和set 的size 为 0，被认为是空。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为空，那么返回 true，否则返回 false。",
        case: `
_.isEmpty(null);
// => true

_.isEmpty(true);
// => true

_.isEmpty(1);
// => true

_.isEmpty([1, 2, 3]);
// => false

_.isEmpty({ 'a': 1 });
// => false
        `,
    },
    {
        key: 20,
        name: "isEqual",
        remark: "判断两者是否相等",
        use: "_.isEqual(value, other)",
        description: `
            执行深比较来确定两者的值是否相等。
注意: 这个方法支持比较 arrays, array buffers, booleans, date objects, error objects, maps, numbers, Object objects, regexes, sets, strings, symbols, 以及 typed arrays. Object 对象值比较自身的属性，不包括继承的和可枚举的属性。 不支持函数和DOM节点比较。
       `,
        argument: `
1.value (*): 用来比较的值。
2.other (*): 另一个用来比较的值。
        `,
        return: "(boolean): 如果 两个值完全相同，那么返回 true，否则返回 false。",
        case: `
var object = { 'a': 1 };
var other = { 'a': 1 };

_.isEqual(object, other);
// => true

object === other;
// => false
        `,
    },
    {
        key: 21,
        name: "isEqualWith",
        remark: "定制化比较两个值",
        use: "_.isEqualWith(value, other, [customizer])",
        description: `
            这个方法类似_.isEqual。 除了它接受一个 customizer 用来定制比较值。 如果 customizer 返回 undefined 将会比较处理方法代替。 customizer 会传入6个参数：(objValue, othValue [, index|key, object, other, stack])
       `,
        argument: `
1.value (*): 用来比较的值。
2.other (*): 另一个用来比较的值。
3.[customizer] (Function): 用来定制比较值的函数。
        `,
        return: "(boolean): 如果 两个值完全相同，那么返回 true，否则返回 false。",
        case: `
function isGreeting(value) {
  return /^h(?:i|ello)$/.test(value);
}

function customizer(objValue, othValue) {
  if (isGreeting(objValue) && isGreeting(othValue)) {
    return true;
  }
}

var array = ['hello', 'goodbye'];
var other = ['hi', 'goodbye'];

_.isEqualWith(array, other, customizer);
// => true
        `,
    },
    {
        key: 22,
        name: "isError",
        remark: "判断是否是错误对象",
        use: "_.isError(value)",
        description: `
            检查 value 是否是 Error, EvalError, RangeError, ReferenceError,SyntaxError, TypeError, 或者 URIError对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个错误（Error）对象，那么返回 true，否则返回 false。",
        case: `
_.isError(new Error);
// => true

_.isError(Error);
// => false
        `,
    },
    {
        key: 23,
        name: "isFinite",
        remark: "判断是否是有限数值",
        use: "_.isFinite(value)",
        description: `
            检查 value 是否是原始有限数值。Number.MAX_VALUE 是JavaScript中最大的浮点数，尝试使用比更大的数字Number.MAX_VALUE，JavaScript将该数字转换为Infinity。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个有限数值，那么返回 true，否则返回 false。",
        case: `
_.isFinite(3);
// => true

_.isFinite(Number.MIN_VALUE);
// => true

_.isFinite(Infinity);
// => false

_.isFinite('3');
// => false
        `,
    },
    {
        key: 24,
        name: "isFunction",
        remark: "判断是否是函数",
        use: "_.isFunction(value)",
        description: `
            检查 value 是否是 Function 对象。
       `,
        argument: `
value (*): 要检查的值
        `,
        return: "(boolean): 如果 value 是一个函数，那么返回 true，否则返回 false。",
        case: `
_.isFunction(_);
// => true

_.isFunction(/abc/);
// => false
        `,
    },
    {
        key: 25,
        name: "isInteger",
        remark: "判断是否是整数",
        use: "_.isInteger(value)",
        description: `
            检查 value 是否为一个整数。注意: 这个方法基于Number.isInteger.
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个整数，那么返回 true，否则返回 false。",
        case: `
_.isInteger(3);
// => true

_.isInteger(Number.MIN_VALUE);
// => false

_.isInteger(Infinity);
// => false

_.isInteger('3');
// => false
        `,
    },
    {
        key: 26,
        name: "isLength",
        remark: "判断是否是有效长度【没理解】",
        use: "_.isLength(value)",
        description: `
            检查 value 是否为有效的类数组长度。注意: 这个函数基于ToLength【ecma-international.org/ecma-262/6.0/#sec-tolength】.
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个有效长度，那么返回 true，否则返回 false。",
        case: `
_.isLength(3);
// => true

_.isLength(Number.MIN_VALUE);
// => false

_.isLength(Infinity);
// => false

_.isLength('3');
// => false
        `,
    },
    {
        key: 27,
        name: "isMap",
        remark: "判断是否是Map对象",
        use: "_.isMap(value)",
        description: `
            检查 value 是否为一个 Map 对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个 Map 对象，那么返回 true，否则返回 false。",
        case: `
_.isMap(new Map);
// => true

_.isMap(new WeakMap);
// => false
        `,
    },
    {
        key: 28,
        name: "isMatch",
        remark: "比较 object 是否含有和 source 完全相等的属性值。",
        use: "_.isMatch(object, source)",
        description: `
            执行一个深度比较，来确定 object 是否含有和 source 完全相等的属性值。注意: 当source为偏应用时，这种方法等价于_.matches。（注：关于偏应用大家可以自己到google上搜索一下）。偏应用比较匹配空数组和空对象source值分别针对任何数组或对象的价值。在_.isEqual中查看支持的值比较列表。
       `,
        argument: `
1.object (Object): 要检查的对象。
2.source (Object): 属性值相匹配的对象。
        `,
        return: "(boolean): 如果object匹配，那么返回 true，否则返回 false",
        case: `
var object = { 'a': 1, 'b': 2 };

_.isMatch(object, { 'b': 2 });
// => true

_.isMatch(object, { 'b': 1 });
// => false
        `,
    },
    {
        key: 29,
        name: "isMatchWith",
        remark: "支持定制比较 object 是否含有和 source 完全相等的属性值。",
        use: "_.isMatchWith(object, source, [customizer])",
        description: `
            这个方法类似_.isMatch。 除了它接受一个 customizer 定制比较的值。 如果 customizer 返回 undefined 将会比较处理方法代替。 customizer 会传入5个参数：(objValue, srcValue, index|key, object, source)。
       `,
        argument: `
1.object (Object): 要检查的对象。
2.source (Object): 属性值相匹配的对象。
3.[customizer] (Function): 这个函数用来定制比较。
        `,
        return: "(boolean): 如果object匹配，那么返回 true，否则返回 false。",
        case: `
function isGreeting(value) {
  return /^h(?:i|ello)$/.test(value);
}

function customizer(objValue, srcValue) {
  if (isGreeting(objValue) && isGreeting(srcValue)) {
    return true;
  }
}

var object = { 'greeting': 'hello' };
var source = { 'greeting': 'hi' };

_.isMatchWith(object, source, customizer);
// => true
        `,
    },
    {
        key: 30,
        name: "isNaN",
        remark: "判断是否是NaN",
        use: "_.isNaN(value)",
        description: `
            检查 value 是否是 NaN 。注意: 这个方法基于Number.isNaN，和全局的isNaN 不同之处在于，全局的isNaN对 于 undefined 和其他非数字的值返回 true。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个 NaN，那么返回 true，否则返回 false。",
        case: `
_.isNaN(NaN);
// => true

_.isNaN(new Number(NaN));
// => true

isNaN(undefined);
// => true

_.isNaN(undefined);
// => false
        `,
    },
    {
        key: 31,
        name: "isNative",
        remark: "判断是否是原生函数",
        use: "_.isNative(value)",
        description: `
            检查 value 是否是一个原生函数。注意： 这种方法不能可靠地检测在core-js包中存在的本地函数，因为 core-js 规避这种检测。尽管有多个请求，core-js 维护者已经明确表态：任何试图修复检测将受阻。这样一来，我们别无选择，只能抛出一个错误。不幸的是，这也影响其他的包，比如依赖于 core-js的babel-polyfill。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是一个 原生函数，那么返回 true，否则返回 false。",
        case: `
_.isNative(Array.prototype.push);
// => true

_.isNative(_);
// => false
        `,
    },
    {
        key: 32,
        name: "isNil",
        remark: "判断是否是 null 或 undefined ",
        use: "_.isNil(value)",
        description: `
            检查 value 是否是 null 或者 undefined。
       `,
        argument: `
xxx
        `,
        return: "(boolean): 如果 value 为 null 或 undefined，那么返回 true，否则返回 false。",
        case: `
_.isNil(null);
// => true

_.isNil(void 0);
// => true

_.isNil(NaN);
// => false
        `,
    },
    {
        key: 33,
        name: "isNull",
        remark: "判断是否是null",
        use: "_.isNull(value)",
        description: `
            检查 value 是否是 null。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为null，那么返回 true，否则返回 false。",
        case: `
_.isNull(null);
// => true

_.isNull(void 0);
// => false
        `,
    },
    {
        key: 34,
        name: "isNumber",
        remark: "判断是否是数值",
        use: "_.isNumber(value)",
        description: `
            检查 value 是否是原始Number数值型 或者 对象。
注意: 要排除 Infinity, -Infinity, 以及 NaN 数值类型，用_.isFinite 方法。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个数值，那么返回 true，否则返回 false。",
        case: `
_.isNumber(3);
// => true

_.isNumber(Number.MIN_VALUE);
// => true

_.isNumber(Infinity);
// => true

_.isNumber('3');
// => false
        `,
    },
    {
        key: 35,
        name: "isObject",
        remark: "判断是否是对象",
        use: "_.isObject(value)",
        description: `
            检查 value 是否为 Object 的language type。 (例如： arrays, functions, objects, regexes,new Number(0), 以及 new String(''))
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个对象，那么返回 true，否则返回 false。",
        case: `
_.isObject({});
// => true

_.isObject([1, 2, 3]);
// => true

_.isObject(_.noop);
// => true

_.isObject(null);
// => false
        `,
    },
    {
        key: 36,
        name: "isObjectLike",
        remark: "判断是否是类对象",
        use: "_.isObjectLike(value)",
        description: `
            检查 value 是否是 类对象。 如果一个值是类对象，那么它不应该是 null，而且 typeof 后的结果是 "object"。
       `,
        argument: `
xxx
        `,
        return: "(boolean): 如果 value 为一个类对象，那么返回 true，否则返回 false。",
        case: `
_.isObjectLike({});
// => true

_.isObjectLike([1, 2, 3]);
// => true

_.isObjectLike(_.noop);
// => false

_.isObjectLike(null);
// => false
        `,
    },
    {
        key: 37,
        name: "isPlainObject",
        remark: "判断是否是普通对象",
        use: "_.isPlainObject(value)",
        description: `
            检查 value 是否是普通对象。 也就是说该对象由 Object 构造函数创建，或者 [[Prototype]] 为 null 。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个普通对象，那么返回 true，否则返回 false。",
        case: `
function Foo() {
  this.a = 1;
}

_.isPlainObject(new Foo);
// => false

_.isPlainObject([1, 2, 3]);
// => false

_.isPlainObject({ 'x': 0, 'y': 0 });
// => true

_.isPlainObject(Object.create(null));
// => true
        `,
    },
    {
        key: 38,
        name: "isRegExp",
        remark: "判断是否是正则表达式",
        use: "_.isRegExp(value)",
        description: `
            检查 value 是否为RegExp对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个正则表达式，那么返回 true，否则返回 false。",
        case: `
_.isRegExp(/abc/);
// => true

_.isRegExp('/abc/');
// => false
        `,
    },
    {
        key: 39,
        name: "isSafeInteger",
        remark: "判断是否是一个安全整数",
        use: "_.isSafeInteger(value)",
        description: `
            检查 value 是否是一个安全整数。 一个安全整数应该是符合 IEEE-754 标准的非双精度浮点数。注意: 这个方法基于Number.isSafeInteger.
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个安全整数，那么返回 true，否则返回 false。",
        case: `
_.isSafeInteger(3);
// => true

_.isSafeInteger(Number.MIN_VALUE);
// => false

_.isSafeInteger(Infinity);
// => false

_.isSafeInteger('3');
// => false
        `,
    },
    {
        key: 40,
        name: "isSet",
        remark: "判断是否是一个Set对象",
        use: "_.isSet(value)",
        description: `
            检查 value 是否是一个Set对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个 set 对象，那么返回 true，否则返回 false。",
        case: `
_.isSet(new Set);
// => true

_.isSet(new WeakSet);
// => false
        `,
    },
    {
        key: 41,
        name: "isString",
        remark: "判断是否是一个字符串",
        use: "_.isString(value)",
        description: `
            检查 value 是否是原始字符串String或者对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个字符串，那么返回 true，否则返回 false。",
        case: `
_.isString('abc');
// => true

_.isString(1);
// => false
        `,
    },
    {
        key: 42,
        name: "isSymbol",
        remark: "判断是否是一个symbol",
        use: "_.isSymbol(value)",
        description: `
            检查 value 是否是原始 Symbol 或者对象。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个 symbol ，那么返回 true，否则返回 false。",
        case: `
_.isSymbol(Symbol.iterator);
// => true

_.isSymbol('abc');
// => false
        `,
    },
    {
        key: 43,
        name: "isTypedArray",
        remark: "判断是否是TypedArray【二进制数据缓冲类数组】",
        use: "_.isTypedArray(value)",
        description: `
            检查 value 是否是 TypedArray 。
            【 TypedArray基本介绍 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/TypedArray】
            【 ArrayBuffer、TypedArray、DataView 的对比和使用 https://juejin.cn/post/7005810137491308580#heading-7】
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个typed array，那么返回 true，否则返回 false。",
        case: `
_.isTypedArray(new Uint8Array);
// => true

_.isTypedArray([]);
// => false
        `,
    },
    {
        key: 44,
        name: "isUndefined",
        remark: "判断是否是 undefined",
        use: "_.isUndefined(value)",
        description: `
            检查 value 是否是 undefined
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 是 undefined ，那么返回 true，否则返回 false。",
        case: `
_.isUndefined(void 0);
// => true

_.isUndefined(null);
// => false
        `,
    },
    {
        key: 45,
        name: "isWeakMap",
        remark: "判断是否是 WeakMap 对象【WeakMap 是键/值对的集合，其键必须是对象或非注册符号，其值为任意 JavaScript 类型】",
        use: "_.isWeakMap(value)",
        description: `
            检查 value 是否是 WeakMap 对象。【WeakMap介绍：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/WeakMap】
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个 WeakMap 对象 ，那么返回 true，否则返回 false。",
        case: `
_.isWeakMap(new WeakMap);
// => true

_.isWeakMap(new Map);
// => false
        `,
    },
    {
        key: 46,
        name: "isWeakSet",
        remark: "判断是否是 WeakSet 对象",
        use: "_.isWeakSet(value)",
        description: `
            value (*): 要检查的值。
       `,
        argument: `
value (*): 要检查的值。
        `,
        return: "(boolean): 如果 value 为一个 WeakSet 对象 ，那么返回 true，否则返回 false。",
        case: `
_.isWeakSet(new WeakSet);
// => true

_.isWeakSet(new Set);
// => false
        `,
    },
    {
        key: 47,
        name: "lt",
        remark: "检查是否小于目标数值，返回boolean值",
        use: "_.lt(value, other)",
        description: `
            检查 value 是否小于 other。
       `,
        argument: `
1.value (*): 用来比较的值。
2.other (*): 另一个用来比较的值。
        `,
        return: "(boolean): 如果value 小于 other 返回 true，否则返回 false。",
        case: `
_.lt(1, 3);
// => true

_.lt(3, 3);
// => false

_.lt(3, 1);
// => false
        `,
    },
    {
        key: 48,
        name: "lte",
        remark: "检查是否小于或者等于目标数值，返回boolean值",
        use: "_.lte(value, other)",
        description: `
            检查 value 是否小于等于 other。
       `,
        argument: `
1.value (*): 用来比较的值。
2.other (*): 另一个用来比较的值。
        `,
        return: "(boolean): 如果value 小于等于 other 返回 true，否则返回 false。",
        case: `
_.lte(1, 3);
// => true

_.lte(3, 3);
// => true

_.lte(3, 1);
// => false
        `,
    },
    {
        key: 49,
        name: "toArray",
        remark: "转换目标为数组",
        use: "_.toArray(value)",
        description: `
            转换 value 为一个数组。
       `,
        argument: `
value (*): 要转换的值。
        `,
        return: "(Array): 返回转换后的数组。",
        case: `
_.toArray({ 'a': 1, 'b': 2 });
// => [1, 2]

_.toArray('abc');
// => ['a', 'b', 'c']

_.toArray(1);
// => []

_.toArray(null);
// => []
        `,
    },
    {
        key: 50,
        name: "toFinite",
        remark: "转换 value 为一个有限数字",
        use: "_.toFinite(value)",
        description: `
            转换 value 为一个有限数字。
       `,
        argument: `
value (*): 要转换的值。
        `,
        return: "(number): 返回转换后的数字。",
        case: `
_.toFinite(3.2);
// => 3.2

_.toFinite(Number.MIN_VALUE);
// => 5e-324

_.toFinite(Infinity);
// => 1.7976931348623157e+308

_.toFinite('3.2');
// => 3.2
        `,
    },
    {
        key: 51,
        name: "toInteger",
        remark: "转换 value 为一个整数",
        use: "_.toInteger(value)",
        description: `
            转换 value 为一个整数。
       `,
        argument: `
value (*): 要转换的值。
        `,
        return: "(number): 返回转换后的整数。",
        case: `
_.toInteger(3.2);
// => 3

_.toInteger(Number.MIN_VALUE);
// => 0

_.toInteger(Infinity);
// => 1.7976931348623157e+308

_.toInteger('3.2');
// => 3
        `,
    },
    {
        key: 52,
        name: "toLength",
        remark: "获取类数组对象的长度",
        use: "_.toLength(value)",
        description: `
            转换 value 为用作类数组对象的长度整数。
       `,
        argument: `
value (*): 要转换的值。
        `,
        return: "(number): 返回转换后的整数。",
        case: `
_.toLength(3.2);
// => 3

_.toLength(Number.MIN_VALUE);
// => 0

_.toLength(Infinity);
// => 4294967295

_.toLength('3.2');
// => 3
        `,
    },
    {
        key: 53,
        name: "toNumber",
        remark: "转换获取数字",
        use: "_.toNumber(value)",
        description: `
            转换 value 为一个数字。
       `,
        argument: `
value (*): 要处理的值。
        `,
        return: "(number): 返回数字。",
        case: `
_.toNumber(3.2);
// => 3.2

_.toNumber(Number.MIN_VALUE);
// => 5e-324

_.toNumber(Infinity);
// => Infinity

_.toNumber('3.2');
// => 3.2
        `,
    },
    {
        key: 54,
        name: "toPlainObject",
        remark: "转换 value 为普通对象",
        use: "_.toPlainObject(value)",
        description: `
            转换 value 为普通对象。 包括继承的可枚举属性。
       `,
        argument: `
value (*): 要转换的值。
        `,
        return: "(Object): 返回转换后的普通对象。",
        case: `
function Foo() {
  this.b = 2;
}

Foo.prototype.c = 3;

_.assign({ 'a': 1 }, new Foo);
// => { 'a': 1, 'b': 2 }

_.assign({ 'a': 1 }, _.toPlainObject(new Foo));
// => { 'a': 1, 'b': 2, 'c': 3 }
        `,
    },
    {
        key: 55,
        name: "toSafeInteger",
        remark: "转安全整数",
        use: "_.toSafeInteger(value)",
        description: `
            转换 value 为安全整数。 安全整数可以用于比较和准确的表示。
       `,
        argument: `
value (*): 要转换的值。
        `,
        return: "(number): 返回转换后的整数。",
        case: `
_.toSafeInteger(3.2);
// => 3

_.toSafeInteger(Number.MIN_VALUE);
// => 0

_.toSafeInteger(Infinity);
// => 9007199254740991

_.toSafeInteger('3.2');
// => 3
        `,
    },
    {
        key: 56,
        name: "toString",
        remark: "转字符串",
        use: "_.toString(value)",
        description: `
            转换 value 为字符串。 null 和 undefined 将返回空字符串。-0 将被转换为字符串"-0"。
       `,
        argument: `
value (*): 要处理的值。
        `,
        return: "(string): 返回字符串。",
        case: `
_.toString(null);
// => ''

_.toString(-0);
// => '-0'

_.toString([1, 2, 3]);
// => '1,2,3'
        `,
    },
];
